#include "mainwindow.h"
#include "ui_mainwindow.h"
#include <QListWidgetItem>
#include <QMessageBox>
#include <QDebug>
#include <QCoreApplication>
#include <QFileDialog>
#include <QStringConverter>
#include <QInputDialog>
#include <QSqlDatabase>
#include <QSqlError>

/**
 * @brief MainWindow类的构造函数
 * @param parent 父窗口对象，默认为nullptr
 * 
 * 初始化主窗口，创建UI界面，设置信号槽连接，初始化特征列表和结果显示
 */
MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
    , m_ruleManager(new RuleManager(this))
    , m_factManager(new FactManager(this))
    , m_inferenceEngine(new InferenceEngine(m_ruleManager, m_factManager, this))
    , m_dbManager(new DatabaseManager(this))
{
    // 设置UI界面
    ui->setupUi(this);
    
    // 连接信号和槽
    connect(ui->addFeatureButton, &QPushButton::clicked, this, &MainWindow::on_addFeatureButton_clicked);
    connect(ui->startButton, &QPushButton::clicked, this, &MainWindow::on_startButton_clicked);
    connect(ui->resetButton, &QPushButton::clicked, this, &MainWindow::on_resetButton_clicked);
    // importDatabaseButton 使用Qt的自动连接机制，无需手动连接
    connect(ui->featureListWidget, &QListWidget::itemClicked, this, &MainWindow::onFeatureItemClicked);
    
    // 连接事实管理器的信号到界面更新槽
    connect(m_factManager, &FactManager::factAdded, this, &MainWindow::onFactAdded);
    connect(m_factManager, &FactManager::factsChanged, this, &MainWindow::updateDynamicDatabaseDisplay);
    
    // 连接规则管理器的信号到界面更新槽
    connect(m_ruleManager, &RuleManager::rulesChanged, this, &MainWindow::onRulesChanged);
    
    // 连接特征管理器的信号到界面更新槽
    connect(m_factManager, &FactManager::featuresChanged, this, &MainWindow::onFeaturesChanged);
    
    // 连接推理机的信号来显示详细的推理过程
    connect(m_inferenceEngine, &InferenceEngine::inferenceStep, this, &MainWindow::updateInferenceProcessDisplay);
    connect(m_inferenceEngine, &InferenceEngine::factAdded, this, &MainWindow::onFactAdded);
    connect(m_inferenceEngine, &InferenceEngine::conflictResolutionStep, this, [this](const QStringList &candidateRuleNames, const QString &selectedRuleName) {
        QString conflictInfo = QString("【冲突消解】从 %1 条候选规则中选择了 '%2'").arg(candidateRuleNames.size()).arg(selectedRuleName);
        updateInferenceProcessDisplay(conflictInfo);
    });
    connect(m_inferenceEngine, &InferenceEngine::inferenceStarted, this, [this]() {
        updateInferenceProcessDisplay("【推理开始】");
    });
    connect(m_inferenceEngine, &InferenceEngine::inferenceCompleted, this, [this](const QString &conclusion) {
        updateInferenceProcessDisplay(QString("【推理完成】最终结论: %1").arg(conclusion));
    });
    
    // 设置数据库管理器
    m_factManager->setDatabaseManager(m_dbManager);
    m_ruleManager->setDatabaseManager(m_dbManager);
    
    // 初始化空的特征列表（不添加默认特征）
    ui->featureListWidget->clear();
    
    // 初始化结果显示（空内容）
    updateResultDisplay();
    updateDynamicDatabaseDisplay();
}

/**
 * @brief MainWindow类的析构函数
 * 
 * 释放UI界面资源
 */
MainWindow::~MainWindow()
{
    delete ui;
}



/**
 * @brief 设置规则类别列表
 * 
 * 从规则管理器获取所有规则类别，并在界面上显示
 */


/**
 * @brief 更新动态数据库显示
 * 
 * 从事实管理器获取所有事实，并在界面上显示当前已知的事实
 */
void MainWindow::updateDynamicDatabaseDisplay()
{
    // 如果动态数据库显示组件不存在，创建它
    QTextEdit *databaseTextEdit = findChild<QTextEdit*>("databaseTextEdit");
    if (!databaseTextEdit) {
        // 创建动态数据库组框
        QGroupBox *databaseGroupBox = new QGroupBox("动态数据库");
        databaseGroupBox->setStyleSheet(
            "QGroupBox {"
            "   font-weight: bold;"
            "   font-size: 14px;"
            "   color: #34495e;"
            "   border: 2px solid #bdc3c7;"
            "   border-radius: 8px;"
            "   margin-top: 10px;"
            "   padding-top: 15px;"
            "   background-color: #ffffff;"
            "}"
            "QGroupBox::title {"
            "   subcontrol-origin: margin;"
            "   subcontrol-position: top left;"
            "   padding: 0 5px;"
            "   color: #2c3e50;"
            "}"
        );
        QVBoxLayout *databaseLayout = new QVBoxLayout;
        databaseGroupBox->setLayout(databaseLayout);
        
        // 创建文本编辑框来显示动态数据库
        databaseTextEdit = new QTextEdit;
        databaseTextEdit->setObjectName("databaseTextEdit");
        databaseTextEdit->setReadOnly(true);
        databaseTextEdit->setStyleSheet(
            "QTextEdit {"
            "   border: 1px solid #bdc3c7;"
            "   border-radius: 5px;"
            "   background-color: #ffffff;"
            "   padding: 5px;"
            "   font-size: 13px;"
            "   color: #2c3e50;"
            "}"
        );
        databaseLayout->addWidget(databaseTextEdit);
        
        // 将动态数据库组框添加到主布局中（在规则选择和控制之间）
        QVBoxLayout *mainLayout = qobject_cast<QVBoxLayout*>(centralWidget()->layout());
        if (mainLayout && mainLayout->count() >= 3) {
            mainLayout->insertWidget(3, databaseGroupBox);
        }
    }
    
    // 更新动态数据库显示
    QString databaseText = "当前事实库:\n";
    QStringList facts = m_factManager->getAllFacts();
    if (facts.isEmpty()) {
        databaseText += "  暂无事实";
    } else {
        for (const QString &fact : facts) {
            databaseText += "  ✓ " + fact + "\n";
        }
    }
    databaseTextEdit->setPlainText(databaseText);
}

/**
 * @brief 更新推理过程显示
 * @param step 推理过程中的消息或步骤
 * 
 * 在界面上显示推理过程中的每一步，包括规则匹配、冲突消解和结论推导等
 */
void MainWindow::updateInferenceProcessDisplay(const QString &step)
{
    // 如果推理过程显示组件不存在，创建它
    QTextEdit *processTextEdit = findChild<QTextEdit*>("processTextEdit");
    if (!processTextEdit) {
        // 创建推理过程组框
        QGroupBox *processGroupBox = new QGroupBox("推理过程");
        processGroupBox->setStyleSheet(
            "QGroupBox {"
            "   font-weight: bold;"
            "   font-size: 16px;"
            "   color: #2c3e50;"
            "   border: 2px solid #3498db;"
            "   border-radius: 8px;"
            "   margin-top: 10px;"
            "   padding-top: 15px;"
            "   background-color: #f8f9fa;"
            "}"
            "QGroupBox::title {"
            "   subcontrol-origin: margin;"
            "   subcontrol-position: top left;"
            "   padding: 0 8px;"
            "   color: #2c3e50;"
            "   font-weight: bold;"
            "}"
        );
        QVBoxLayout *processLayout = new QVBoxLayout;
        processGroupBox->setLayout(processLayout);
        
        // 创建文本编辑框来显示推理过程
        processTextEdit = new QTextEdit;
        processTextEdit->setObjectName("processTextEdit");
        processTextEdit->setReadOnly(true);
        processTextEdit->setStyleSheet(
            "QTextEdit {"
            "   border: 1px solid #3498db;"
            "   border-radius: 5px;"
            "   background-color: #ffffff;"
            "   padding: 8px;"
            "   font-size: 14px;"
            "   color: #2c3e50;"
            "   line-height: 1.5;"
            "}"
        );
        processLayout->addWidget(processTextEdit);
        
        // 将推理过程组框添加到主布局中（在控制和结果之间）
        QVBoxLayout *mainLayout = qobject_cast<QVBoxLayout*>(centralWidget()->layout());
        if (mainLayout && mainLayout->count() >= 4) {
            mainLayout->insertWidget(5, processGroupBox);
        }
    }
    
    // 更新推理过程显示，使用富文本格式支持加粗和颜色
    QTextCursor cursor = processTextEdit->textCursor();
    cursor.movePosition(QTextCursor::End);
    
    // 创建文本块格式
    QTextBlockFormat blockFormat;
    blockFormat.setBottomMargin(3); // 减少间距，使显示更紧凑
    cursor.setBlockFormat(blockFormat);
    
    // 创建字符格式
    QTextCharFormat charFormat;
    
    // 根据步骤内容设置不同的格式
    QString formattedStep = step;

    // 为特定关键词添加加粗效果
    if (step.contains("推理轮次")) {
        // 简化轮次信息显示
        formattedStep = formattedStep.replace("当前已知事实数量:", "事实数:");
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#2980b9"));
    } else if (step.contains("匹配的规则")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#27ae60"));
    } else if (step.contains("应用规则")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#8e44ad"));
    } else if (step.contains("推导出")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#d35400"));
    } else if (step.contains("推理完成") || step.contains("最终结论")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#c0392b"));
        charFormat.setFontPointSize(16);
    } else if (step.contains("冲突消解")) {
        // 简化冲突消解信息显示
        formattedStep = formattedStep.replace("从", "").replace("条候选规则中选择了", "条规则中选择:");
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#f39c12"));
    } else if (step.contains("推理开始")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#16a085"));
        charFormat.setFontPointSize(15);
    } else if (step.contains("初始事实")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#34495e"));
    } else if (step.contains("开始推理")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#7f8c8d"));
    } else if (step.contains("得出结论")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#c0392b"));
        charFormat.setFontPointSize(15);
    } else if (step.contains("无匹配规则")) {
        charFormat.setFontWeight(QFont::Bold);
        charFormat.setForeground(QColor("#e74c3c"));
    } else {
        charFormat.setFontWeight(QFont::Normal);
        charFormat.setForeground(QColor("#2c3e50"));
    }
    
    // 插入格式化的文本
    cursor.insertText(formattedStep + "\n", charFormat);
    
    // 滚动到底部
    processTextEdit->setTextCursor(cursor);
    processTextEdit->ensureCursorVisible();
}

/**
 * @brief 更新结果显示
 * 
 * 显示当前已选择的特征列表，并更新动态数据库显示
 */
void MainWindow::updateResultDisplay()
{
    QString resultText = "已选择的特征:\n";
    for (const QString &feature : m_selectedFeatures) {
        resultText += "  ✓ " + feature + "\n";
    }
    
    // 不显示默认提示信息
    resultText += "\n请加载知识库文件并选择特征开始推理...";
    ui->resultTextEdit->setPlainText(resultText);
    
    // 更新动态数据库显示
    updateDynamicDatabaseDisplay();
}

/**
 * @brief 添加特征按钮点击事件处理函数
 * 
 * 从自定义特征输入框获取文本，检查是否已存在，如果不存在则添加到特征列表中，
 * 并设置为新选中状态，同时更新结果显示
 */
void MainWindow::on_addFeatureButton_clicked()
{
    QString customFeature = ui->customFeatureLineEdit->text().trimmed();
    if (!customFeature.isEmpty()) {
        // 检查是否已存在
        bool exists = false;
        for (int i = 0; i < ui->featureListWidget->count(); ++i) {
            if (ui->featureListWidget->item(i)->text() == customFeature) {
                exists = true;
                break;
            }
        }
        
        if (!exists) {
            QListWidgetItem *item = new QListWidgetItem(customFeature, ui->featureListWidget);
            item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
            item->setCheckState(Qt::Checked);
            // 为新添加的选中项添加背景色
            item->setBackground(QColor("#e3f2fd"));  // 浅蓝色背景
            item->setForeground(QColor("#FFD700"));  // 黄色文字
            m_selectedFeatures.append(customFeature);
        } else {
            QMessageBox::information(this, "提示", "该特征已存在！");
        }
        
        ui->customFeatureLineEdit->clear();
        updateResultDisplay();
    }
}

/**
 * @brief 开始推理按钮点击事件处理函数
 * 
 * 检查是否有选中的特征，清空之前的推理过程显示，设置初始事实，
 * 启动前向推理，并根据推理结果显示最终结论或提示信息
 */
void MainWindow::on_startButton_clicked()
{
    if (m_selectedFeatures.isEmpty()) {
        QMessageBox::warning(this, "警告", "请至少选择一个特征！");
        return;
    }
    
    // 清空之前的推理过程显示
    QTextEdit *processTextEdit = findChild<QTextEdit*>("processTextEdit");
    if (processTextEdit) {
        processTextEdit->clear();
        updateInferenceProcessDisplay("【推理开始】");
        updateInferenceProcessDisplay("【初始事实】");
        for (const QString &feature : m_selectedFeatures) {
            updateInferenceProcessDisplay("  ✓ " + feature);
        }
    }
    
    // 清空并设置事实
    m_factManager->clearFacts();
    m_factManager->addFacts(m_selectedFeatures);
    
    // 开始前向推理
    QString conclusion = m_inferenceEngine->forwardChaining();
    
    // 显示最终结论
    if (!conclusion.isEmpty()) {
        QString resultText = "已选择的特征:\n";
        for (const QString &feature : m_selectedFeatures) {
            resultText += "  ✓ " + feature + "\n";
        }
        resultText += "\n\n推理完成！\n" + conclusion;
        ui->resultTextEdit->setPlainText(resultText);
        
        // 在推理过程中添加最终结论
        if (processTextEdit) {
            processTextEdit->append("\n=== 推理完成 ===");
            processTextEdit->append("结论：" + conclusion);
        }
    } else {
        QString resultText = "已选择的特征:\n";
        for (const QString &feature : m_selectedFeatures) {
            resultText += "  ✓ " + feature + "\n";
        }
        resultText += "\n\n无法得出确定的结论，请提供更多特征信息。";
        ui->resultTextEdit->setPlainText(resultText);
        
        // 在推理过程中添加无法得出结论的信息
        if (processTextEdit) {
            processTextEdit->append("\n=== 推理完成 ===");
            processTextEdit->append("无法得出确定的结论，请提供更多特征信息。");
        }
    }
}

/**
 * @brief 重置按钮点击事件处理函数
 * 
 * 清空所有选中的特征、事实和推理结果，将系统恢复到初始状态
 */
void MainWindow::on_resetButton_clicked()
{
    // 重置所有选择
    for (int i = 0; i < ui->featureListWidget->count(); ++i) {
        QListWidgetItem *item = ui->featureListWidget->item(i);
        item->setCheckState(Qt::Unchecked);
        // 恢复未选中项的默认样式
        item->setBackground(QColor("#ffffff"));  // 白色背景
        item->setForeground(QColor("#2c3e50"));  // 默认文字颜色
    }
    
    m_selectedFeatures.clear();
    ui->customFeatureLineEdit->clear();
    
    // 清空推理过程显示
    QTextEdit *processTextEdit = findChild<QTextEdit*>("processTextEdit");
    if (processTextEdit) {
        processTextEdit->clear();
        updateInferenceProcessDisplay("【系统重置】推理过程已重置，请选择特征并点击开始按钮进行新的推理。");
    }
    
    // 清空事实库
    m_factManager->clearFacts();
    
    updateResultDisplay();
}

/**
 * @brief 特征列表项点击事件处理函数
 * @param item 被点击的特征列表项
 * 
 * 当用户点击特征列表中的某一项时，切换该特征的选中状态，
 * 更新已选特征列表，并应用相应的样式变化
 */
void MainWindow::onFeatureItemClicked(QListWidgetItem *item)
{
    QString feature = item->text();
    
    if (item->checkState() == Qt::Checked) {
        if (!m_selectedFeatures.contains(feature)) {
            m_selectedFeatures.append(feature);
            // 为选中的项添加背景色
            item->setBackground(QColor("#e3f2fd"));  // 浅蓝色背景
            item->setForeground(QColor("#FFD700"));  // 黄色文字
        }
    } else {
        m_selectedFeatures.removeAll(feature);
        // 恢复未选中项的默认样式
        item->setBackground(QColor("#ffffff"));  // 白色背景
        item->setForeground(QColor("#2c3e50"));  // 默认文字颜色
    }
    
    updateResultDisplay();
}

/**
 * @brief 事实添加事件处理函数
 * @param fact 被添加的事实
 * 
 * 当事实管理器添加新事实时，更新结果显示和推理过程显示，
 * 以反映新添加的事实
 */
void MainWindow::onFactAdded(const QString &fact)
{
    QString resultText = ui->resultTextEdit->toPlainText();
    resultText += "\n推导出新事实: " + fact;
    ui->resultTextEdit->setPlainText(resultText);
    ui->resultTextEdit->moveCursor(QTextCursor::End);
    
    // 在推理过程中添加新事实
    QTextEdit *processTextEdit = findChild<QTextEdit*>("processTextEdit");
    if (processTextEdit) {
        processTextEdit->append("推导出新事实: " + fact);
    }
}



/**
 * @brief 导入特征按钮点击事件处理函数
 * 
 * 打开文件选择对话框，让用户选择特征文件，然后从文件中导入特征
 */
void MainWindow::on_importFeaturesButton_clicked()
{
    // 弹出文件选择对话框，让用户选择特征文件
    QString filePath = QFileDialog::getOpenFileName(this, 
                                                   tr("选择特征文件"), 
                                                   QCoreApplication::applicationDirPath(), 
                                                   tr("文本文件 (*.txt);;所有文件 (*.*)"));
    
    // 如果用户取消了选择，则返回
    if (filePath.isEmpty()) {
        return;
    }
    
    importFeaturesFromFile(filePath);
}

/**
 * @brief 导入规则按钮点击事件处理函数
 * 
 * 打开文件选择对话框，让用户选择规则文件，然后从文件中导入规则
 */
void MainWindow::on_importRulesButton_clicked()
{
    // 弹出文件选择对话框，让用户选择规则文件
    QString filePath = QFileDialog::getOpenFileName(this, 
                                                   tr("选择规则文件"), 
                                                   QCoreApplication::applicationDirPath(), 
                                                   tr("文本文件 (*.txt);;所有文件 (*.*)"));
    
    // 如果用户取消了选择，则返回
    if (filePath.isEmpty()) {
        return;
    }
    
    importRulesFromFile(filePath);
}

/**
 * @brief 从文件导入特征
 * @param filePath 特征文件的路径
 * 
 * 读取特征文件，解析其中的特征，并将它们添加到特征列表中
 */
void MainWindow::importFeaturesFromFile(const QString &filePath)
{
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        QMessageBox::warning(this, "警告", "无法打开特征文件！\n" + filePath);
        return;
    }
    
    QTextStream in(&file);
    in.setEncoding(QStringConverter::Utf8);
    QString line;
    QStringList features;
    
    while (!in.atEnd()) {
        line = in.readLine().trimmed();
        
        if (line.isEmpty()) {
            continue;
        }
        
        // 跳过注释行
        if (line.startsWith("#")) {
            continue;
        }
        
        // 解析特征，格式为：特征:特征名
        if (line.startsWith("特征:")) {
            QString feature = line.mid(3).trimmed(); // 去掉 "特征:" 并去除首尾空格
            if (!feature.isEmpty()) {
                features.append(feature);
            }
        }
    }
    
    file.close();
    
    // 更新特征列表
    ui->featureListWidget->clear();
    for (const QString &feature : features) {
        QListWidgetItem *item = new QListWidgetItem(feature, ui->featureListWidget);
        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
        item->setCheckState(Qt::Unchecked);
        // 设置未选中项的默认样式
        item->setBackground(QColor("#ffffff"));  // 白色背景
        item->setForeground(QColor("#2c3e50"));  // 默认文字颜色
    }
    
    // 清空已选择的特征
    m_selectedFeatures.clear();
    
    // 更新显示
    updateResultDisplay();
    updateDynamicDatabaseDisplay();
    
    // 显示加载结果
    QMessageBox::information(this, "成功", "特征导入成功！\n导入了 " + QString::number(features.size()) + " 个特征。");
}

/**
 * @brief 从文件导入规则
 * @param filePath 规则文件的路径
 * 
 * 读取规则文件，解析其中的规则，并将它们添加到规则管理器中
 */
void MainWindow::importRulesFromFile(const QString &filePath)
{
    QFile file(filePath);
    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
        QMessageBox::warning(this, "警告", "无法打开规则文件！\n" + filePath);
        return;
    }
    
    QTextStream in(&file);
    in.setEncoding(QStringConverter::Utf8);
    QString line;
    int ruleCount = 0;
    
    // 清空现有规则
    m_ruleManager->clearRules();
    
    while (!in.atEnd()) {
        line = in.readLine().trimmed();
        
        if (line.isEmpty()) {
            continue;
        }
        
        // 跳过注释行
        if (line.startsWith("#")) {
            continue;
        }
        
        // 解析规则，格式为：规则:规则名,类别:类别名,前提:前提1,前提2,...,结论:结论
        if (line.startsWith("规则:")) {
            QString ruleContent = line.mid(3).trimmed(); // 去掉 "规则:" 并去除首尾空格
            
            // 提取规则名
            int firstCommaPos = ruleContent.indexOf(",");
            if (firstCommaPos == -1) continue;
            QString ruleName = ruleContent.left(firstCommaPos).trimmed();
            
            // 提取类别
            int categoryPos = ruleContent.indexOf("类别:");
            if (categoryPos == -1) continue;
            int nextCommaPos = ruleContent.indexOf(",", categoryPos);
            QString category = ruleContent.mid(categoryPos + 3, nextCommaPos - categoryPos - 3).trimmed();
            
            // 提取前提
            int premisePos = ruleContent.indexOf("前提:");
            if (premisePos == -1) continue;
            int conclusionPos = ruleContent.indexOf("结论:");
            if (conclusionPos == -1) continue;
            
            QString premiseStr = ruleContent.mid(premisePos + 3, conclusionPos - premisePos - 3).trimmed();
            QStringList conditions = premiseStr.split(",", Qt::SkipEmptyParts);
            
            // 去除每个条件的首尾空格
            for (int i = 0; i < conditions.size(); ++i) {
                conditions[i] = conditions[i].trimmed();
            }
            
            // 提取结论
            QString conclusion = ruleContent.mid(conclusionPos + 3).trimmed();
            
            // 添加规则
            if (!conditions.isEmpty() && !conclusion.isEmpty() && !category.isEmpty() && !ruleName.isEmpty()) {
                QString fullRuleName = category + ":" + ruleName;
                m_ruleManager->addRule(Rule(fullRuleName, conditions, conclusion));
                ruleCount++;
            }
        }
    }
    
    file.close();
    
    // 显示加载结果
    int actualRuleCount = m_ruleManager->getAllRules().size();
    QMessageBox::information(this, "成功", "规则导入成功！\n导入了 " + QString::number(actualRuleCount) + " 条规则。");
}

/**
 * @brief 导入数据库按钮点击事件处理函数
 * 
 * 连接到数据库并导入特征和规则
 */
void MainWindow::on_importDatabaseButton_clicked()
{
    // 使用默认连接信息直接连接数据库
    QString hostname = "localhost";  // 默认服务器地址
    QString databaseName = "AnimalExpertSystem";  // 默认数据库名称
    QString username = "";  // 默认用户名（使用Windows身份验证）
    QString password = "";  // 默认密码（使用Windows身份验证）
    
    // 连接到数据库
    if (!connectToDatabase(hostname, databaseName, username, password)) {
        QMessageBox::warning(this, "失败", "数据库连接失败！\n" + m_dbManager->lastError());
        return;
    }
    
    // 从数据库导入特征
    if (!importFeaturesFromDatabase()) {
        QMessageBox::warning(this, "失败", "从数据库导入特征失败！\n" + m_dbManager->lastError());
        return;
    }
    
    // 从数据库导入规则
    if (!importRulesFromDatabase()) {
        QMessageBox::warning(this, "失败", "从数据库导入规则失败！\n" + m_dbManager->lastError());
        return;
    }
    
    QMessageBox::information(this, "成功", "从数据库导入特征和规则成功！");
}





/**
 * @brief 规则变化事件处理函数
 */
void MainWindow::onRulesChanged()
{
    // 规则已更新，无需额外处理
}

/**
 * @brief 特征变化事件处理函数
 */
void MainWindow::onFeaturesChanged()
{
    // 更新特征列表
    QStringList features = m_factManager->getAvailableFeatures();
    ui->featureListWidget->clear();
    for (const QString &feature : features) {
        QListWidgetItem *item = new QListWidgetItem(feature, ui->featureListWidget);
        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
        item->setCheckState(Qt::Unchecked);
        // 设置未选中项的默认样式
        item->setBackground(QColor("#ffffff"));  // 白色背景
        item->setForeground(QColor("#2c3e50"));  // 默认文字颜色
    }
    
    // 清空已选择的特征
    m_selectedFeatures.clear();
    
    // 更新显示
    updateResultDisplay();
    updateDynamicDatabaseDisplay();
}

/**
 * @brief 连接到数据库
 * @param hostname 数据库服务器地址
 * @param databaseName 数据库名称
 * @param username 用户名
 * @param password 密码
 * @return 如果连接成功则返回true，否则返回false
 */
bool MainWindow::connectToDatabase(const QString &hostname, const QString &databaseName, 
                                  const QString &username, const QString &password)
{
    return m_dbManager->connectToDatabase(hostname, databaseName, username, password);
}

/**
 * @brief 从数据库导入特征
 * @return 如果导入成功则返回true，否则返回false
 */
bool MainWindow::importFeaturesFromDatabase()
{
    if (!m_factManager->loadFeaturesFromDatabase()) {
        return false;
    }
    
    // 更新特征列表
    QStringList features = m_factManager->getAvailableFeatures();
    ui->featureListWidget->clear();
    for (const QString &feature : features) {
        QListWidgetItem *item = new QListWidgetItem(feature, ui->featureListWidget);
        item->setFlags(item->flags() | Qt::ItemIsUserCheckable);
        item->setCheckState(Qt::Unchecked);
        // 设置未选中项的默认样式
        item->setBackground(QColor("#ffffff"));  // 白色背景
        item->setForeground(QColor("#2c3e50"));  // 默认文字颜色
    }
    
    // 清空已选择的特征
    m_selectedFeatures.clear();
    
    // 更新显示
    updateResultDisplay();
    updateDynamicDatabaseDisplay();
    
    return true;
}

/**
 * @brief 管理特征和规则按钮点击事件处理函数
 * 
 * 打开管理对话框，允许用户对特征和规则进行增删改查操作
 */
void MainWindow::on_manageButton_clicked()
{
    // 创建管理对话框
    ManagementDialog dialog(this);
    
    // 显示对话框
    if (dialog.exec() == QDialog::Accepted) {
        // 对话框关闭后，刷新主界面的特征列表
        onFeaturesChanged();
        onRulesChanged();
    }
}

/**
 * @brief 从数据库导入规则
 * @return 如果导入成功则返回true，否则返回false
 */
bool MainWindow::importRulesFromDatabase()
{
    if (!m_ruleManager->loadRulesFromDatabase()) {
        return false;
    }
    
    return true;
}
